/**
 * 图片优化配置管理
 */

const { createLogger } = require('../../logger');

const logger = createLogger('image-optimization-config');

class ImageOptimizationConfig {
    constructor() {
        // 默认配置
        this.defaultConfig = {
            // 基础设置
            enabled: true,
            maxFileSize: 1 * 1024 * 1024, // 1MB阈值

            // 质量设置
            qualityLevels: {
                high: {
                    quality: 0.9,           // JPEG质量 (0-1)
                    maxDimension: 2048,      // 最大分辨率
                    description: '高质量 - 保持细节，适合高质量分析'
                },
                medium: {
                    quality: 0.8,
                    maxDimension: 1536,
                    description: '中等质量 - 平衡质量和大小'
                },
                low: {
                    quality: 0.7,
                    maxDimension: 1024,
                    description: '低质量 - 优先减小文件大小'
                },
                ultra: {
                    quality: 0.6,
                    maxDimension: 800,
                    description: '超低质量 - 最大程度压缩'
                }
            },

            // 格式设置
            preferredFormat: 'jpeg',           // 首选输出格式
            enableFormatConversion: true,      // 启用格式转换
            progressiveJPEG: true,             // 渐进式JPEG

            // 分辨率设置
            targetDimensions: {
                width: 1920,
                height: 1080
            },
            minDimensions: {
                width: 800,
                height: 600
            },

            // 元数据设置
            stripMetadata: true,               // 清除元数据
            preserveColorProfile: false,       // 保留色彩配置文件

            // 压缩设置
            enableLossyCompression: true,      // 启用有损压缩
            aggressiveCompression: false,      // 激进压缩模式
            maxCompressionAttempts: 3,         // 最大压缩尝试次数

            // 缓存设置
            enableCache: true,                 // 启用优化结果缓存
            cacheDir: './tmp/image-cache',     // 缓存目录
            maxCacheSize: 100 * 1024 * 1024,   // 最大缓存大小 100MB

            // 性能设置
            parallelProcessing: false,         // 并行处理
            timeout: 30000,                   // 优化超时时间 (ms)
        };

        // 任务类型特定配置
        this.taskSpecificConfigs = {
            generate_html_from_prototype: {
                quality: 'medium',           // HTML生成需要较好的图片质量
                maxDimension: 1280,
                description: 'HTML生成任务 - 保持足够细节进行代码生成'
            },
            analyze_design_screenshot: {
                quality: 'high',             // 设计分析需要高质量
                maxDimension: 1920,
                description: '设计分析任务 - 需要高质量保留设计细节'
            },
            compare_image: {
                quality: 'medium',           // 图片对比中等质量即可
                maxDimension: 1024,
                description: '图片对比任务 - 平衡质量和性能'
            },
            extract_component_hierarchy: {
                quality: 'low',              // 组件层次结构分析
                maxDimension: 800,
                description: '组件分析任务 - 主要关注结构，可以降低质量'
            },
            default: {
                quality: 'medium',
                maxDimension: 1280,
                description: '默认任务配置'
            }
        };
    }

    /**
     * 获取任务配置
     * @param {string} taskType - 任务类型
     * @param {Object} overrideConfig - 覆盖配置
     * @returns {Object} - 配置对象
     */
    getTaskConfig(taskType, overrideConfig = {}) {
        const baseConfig = this.defaultConfig;
        const taskConfig = this.taskSpecificConfigs[taskType] || this.taskSpecificConfigs.default;

        // 合并配置
        const mergedConfig = {
            ...baseConfig,
            ...taskConfig,
            ...overrideConfig
        };

        // 获取质量等级详细配置
        const qualityConfig = baseConfig.qualityLevels[mergedConfig.quality];
        if (qualityConfig) {
            mergedConfig.targetQuality = qualityConfig.quality;
            mergedConfig.maxDimension = qualityConfig.maxDimension;
            mergedConfig.qualityDescription = qualityConfig.description;
        }

        logger.debug(`获取任务配置: ${taskType} -> 质量: ${mergedConfig.quality}, 最大尺寸: ${mergedConfig.maxDimension}`);

        return mergedConfig;
    }

    /**
     * 自动选择最佳配置
     * @param {Object} imageInfo - 图片信息
     * @param {string} taskType - 任务类型
     * @returns {Object} - 推荐配置
     */
    getAutoConfig(imageInfo, taskType) {
        const sizeMB = parseFloat(imageInfo.sizeMB);
        const taskConfig = this.getTaskConfig(taskType);

        // 根据图片大小自动调整质量等级
        let recommendedQuality = taskConfig.quality;
        let recommendedMaxDimension = taskConfig.maxDimension;

        if (sizeMB > 5) {
            // 超大图片，使用激进压缩
            recommendedQuality = 'ultra';
            recommendedMaxDimension = 800;
        } else if (sizeMB > 3) {
            // 大图片，使用高压缩
            recommendedQuality = 'low';
            recommendedMaxDimension = 1024;
        } else if (sizeMB > 1) {
            // 中等图片，使用中等压缩
            recommendedQuality = 'medium';
            recommendedMaxDimension = 1280;
        } else {
            // 小图片，保持高质量
            recommendedQuality = 'high';
            recommendedMaxDimension = taskConfig.maxDimension;
        }

        // 根据任务类型调整
        const taskAdjustment = this.getTaskAdjustment(taskType, imageInfo);
        recommendedQuality = this.adjustQualityForTask(recommendedQuality, taskAdjustment);
        recommendedMaxDimension = Math.min(recommendedMaxDimension, taskConfig.maxDimension);

        const config = this.getTaskConfig(taskType, {
            quality: recommendedQuality,
            maxDimension: recommendedMaxDimension
        });

        config.reasoning = `自动选择配置: ${sizeMB}MB图片, 任务类型: ${taskType}, 质量: ${recommendedQuality}`;
        logger.info(config.reasoning);

        return config;
    }

    /**
     * 获取任务调整因子
     * @param {string} taskType - 任务类型
     * @param {Object} imageInfo - 图片信息
     * @returns {Object} - 调整因子
     */
    getTaskAdjustment(taskType, imageInfo) {
        const adjustments = {
            generate_html_from_prototype: {
                qualityFactor: 0.1,    // HTML生成需要更高质量
                sizeFactor: 0.2        // 可以接受较大的文件
            },
            analyze_design_screenshot: {
                qualityFactor: 0.2,    // 设计分析需要高质量
                sizeFactor: 0.3
            },
            compare_image: {
                qualityFactor: -0.1,   // 对比任务可以降低质量
                sizeFactor: -0.2
            },
            extract_component_hierarchy: {
                qualityFactor: -0.3,   // 结构分析可以大幅降低质量
                sizeFactor: -0.4
            }
        };

        return adjustments[taskType] || { qualityFactor: 0, sizeFactor: 0 };
    }

    /**
     * 根据任务调整质量等级
     * @param {string} baseQuality - 基础质量等级
     * @param {Object} adjustment - 调整因子
     * @returns {string} - 调整后的质量等级
     */
    adjustQualityForTask(baseQuality, adjustment) {
        const qualityLevels = ['ultra', 'low', 'medium', 'high'];
        const currentIndex = qualityLevels.indexOf(baseQuality);

        if (currentIndex === -1) return baseQuality;

        let adjustedIndex = currentIndex;
        const qualityFactor = adjustment.qualityFactor || 0;

        if (qualityFactor > 0.15) {
            // 需要提高质量
            adjustedIndex = Math.min(currentIndex + 1, qualityLevels.length - 1);
        } else if (qualityFactor < -0.15) {
            // 需要降低质量
            adjustedIndex = Math.max(currentIndex - 1, 0);
        }

        return qualityLevels[adjustedIndex];
    }

    /**
     * 验证配置
     * @param {Object} config - 配置对象
     * @returns {Object} - 验证结果
     */
    validateConfig(config) {
        const errors = [];
        const warnings = [];

        // 检查必需字段
        if (typeof config.enabled !== 'boolean') {
            errors.push('enabled必须是布尔值');
        }

        if (typeof config.maxFileSize !== 'number' || config.maxFileSize <= 0) {
            errors.push('maxFileSize必须是正数');
        }

        if (config.targetQuality && (config.targetQuality < 0 || config.targetQuality > 1)) {
            errors.push('targetQuality必须在0-1之间');
        }

        // 检查警告
        if (config.targetQuality && config.targetQuality < 0.5) {
            warnings.push('targetQuality低于0.5可能导致图片质量严重下降');
        }

        if (config.maxDimension && config.maxDimension > 4096) {
            warnings.push('maxDimension过大可能导致优化效果不佳');
        }

        return {
            valid: errors.length === 0,
            errors,
            warnings
        };
    }

    /**
     * 获取配置摘要
     * @param {Object} config - 配置对象
     * @returns {string} - 配置摘要
     */
    getConfigSummary(config) {
        const parts = [];

        if (config.enabled) {
            parts.push(`启用优化`);
        } else {
            parts.push(`禁用优化`);
            return parts.join(', ');
        }

        if (config.targetQuality) {
            parts.push(`质量: ${(config.targetQuality * 100).toFixed(0)}%`);
        }

        if (config.maxDimension) {
            parts.push(`最大尺寸: ${config.maxDimension}px`);
        }

        if (config.enableFormatConversion) {
            parts.push(`格式转换: ${config.preferredFormat}`);
        }

        if (config.stripMetadata) {
            parts.push(`清除元数据`);
        }

        return parts.join(', ');
    }

    /**
     * 更新默认配置
     * @param {Object} newConfig - 新配置
     * @returns {boolean} - 是否更新成功
     */
    updateDefaultConfig(newConfig) {
        try {
            const validation = this.validateConfig(newConfig);
            if (!validation.valid) {
                logger.error('配置验证失败:', validation.errors);
                return false;
            }

            if (validation.warnings.length > 0) {
                logger.warn('配置警告:', validation.warnings);
            }

            this.defaultConfig = { ...this.defaultConfig, ...newConfig };
            logger.info('默认配置已更新');
            return true;

        } catch (error) {
            logger.error('更新配置失败:', error.message);
            return false;
        }
    }

    /**
     * 获取当前配置
     * @returns {Object} - 当前配置
     */
    getCurrentConfig() {
        return {
            default: { ...this.defaultConfig },
            taskSpecific: { ...this.taskSpecificConfigs }
        };
    }

    /**
     * 重置为默认配置
     */
    resetToDefaults() {
        this.defaultConfig = this.constructor().prototype.defaultConfig;
        logger.info('配置已重置为默认值');
    }

    /**
     * 导出配置
     * @param {string} filePath - 导出文件路径
     * @returns {boolean} - 是否导出成功
     */
    exportConfig(filePath) {
        try {
            const fs = require('fs');
            const config = this.getCurrentConfig();
            fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
            logger.info(`配置已导出到: ${filePath}`);
            return true;
        } catch (error) {
            logger.error('配置导出失败:', error.message);
            return false;
        }
    }

    /**
     * 导入配置
     * @param {string} filePath - 导入文件路径
     * @returns {boolean} - 是否导入成功
     */
    importConfig(filePath) {
        try {
            const fs = require('fs');
            const configData = JSON.parse(fs.readFileSync(filePath, 'utf8'));

            if (configData.default) {
                this.defaultConfig = { ...this.defaultConfig, ...configData.default };
            }

            if (configData.taskSpecific) {
                this.taskSpecificConfigs = { ...this.taskSpecificConfigs, ...configData.taskSpecific };
            }

            logger.info(`配置已从文件导入: ${filePath}`);
            return true;
        } catch (error) {
            logger.error('配置导入失败:', error.message);
            return false;
        }
    }
}

module.exports = ImageOptimizationConfig;